package com.xjggb.双向链表;

import com.xjggb.链表.AbstractList;

public class CircleLinkedList<E> extends AbstractList<E> {
    private Node<E> firt;
    private Node<E> last;
    private Node<E> current;


    private static  class Node<E>{
        E element;
        Node<E> prev;
        Node<E> next;
        public Node(Node<E> prev, E element,Node<E> next){
            this.prev=prev;
            this.element=element;
            this.next=next;
        }
    }

    public void clear() {
        size=0;
        firt=null;
        last=null;


    }

    public E get(int index) {

        return node(index).element;
    }

    public E set(int index, E element) {
        return null;
    }

    public void add(int index, E element) {

        if (index==size){
            Node<E> oldLast = last;
            last = new Node<E>(oldLast, element, firt);
            if (oldLast == null) { // 这是链表添加的第一个元素
                firt = last;
                firt.next = firt;
                firt.prev = firt;
            } else {
                oldLast.next = last;
                firt.prev = last;
            }

        }else {
            //        获取当前节点
            Node<E> next = node(index);
//        获取上一节点
            Node<E> prev = next.prev;
//        创建新的节点
            Node<E> node  = new Node<E>(prev, element, next);
            next.prev=node;
            prev.next=node;
            if (next==firt){  //index==0
                firt=node;
            }
        }
  size++;

    }
    public E remove(int index) {
        return remove( node(index));
    }

    private E remove(Node<E> node) {

        if (size==1){
            firt=null;
            last=null;
        }else {
//            获取上一节点
            Node<E> prev = node.prev;
//            获取下一节点
            Node<E> next = node.next;
//            上一节点指向下一节点
            prev.next=next;
//            下一节点指向上一节点
            next.prev=prev;
        }
        size--;
        return node.element;
    }


    public int indexOf(E element) {
        return 0;
    }
    /*
    * 根据index位置获取节点对象
    * */

    private Node<E> node(int index){
//        检查index是否合格
        rangeCheck(index);
      /*
      * 获取size的中间值he传入的index比较是从左边开始遍历还是右边
      * */
        if (index<(size>>1)){
            Node<E> node =firt;
            for (int i = 0; i < index; i++) {
                 node=node.next;
            }
            return node;
        }else {
            /*
            * 从右边开始遍历
            * */
            Node<E> node = this.last;
            for (int i = size-1; i >index; i--) {
                 node = node.prev;
            }
            return node;
        }


    }



}
